package com.wss.common.net;

import com.orhanobut.logger.Logger;
import com.wss.common.base.BaseApplication;
import com.wss.common.base.ResourceTable;
import com.wss.common.constants.Constants;
import com.wss.common.exception.NetErrorException;
import com.wss.common.manage.AbilityToAbility;
import com.wss.common.net.request.RequestParam;
import com.wss.common.net.response.BaseResponse;
import com.wss.common.utils.*;
import com.zhouyou.http.EasyHttp;
import com.zhouyou.http.callback.CallBack;
import com.zhouyou.http.callback.SimpleCallBack;
import com.zhouyou.http.exception.ApiException;
import com.zhouyou.http.model.HttpParams;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.schedulers.Schedulers;
import ohos.aafwk.ability.ILifecycle;
import ohos.agp.components.Text;
import ohos.eventhandler.EventHandler;
import ohos.eventhandler.EventRunner;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;


/**
 * Describe：网络请求帮助类
 * Created by 吴天强 on 2020/1/3.
 */
@SuppressWarnings("unchecked")
public class NetworkManage {
    /**
     * 取第一个进来的跳转到登录页
     */
    public volatile static int count = 0;
    private static final String GET = "GET";
    private static final String POST_FORM = "POST_FORM";
    private static final String POST_JSON = "POST_JSON";
    private static final String PUT_FORM = "PUT_FORM";
    private static final String PUT_JSON = "PUT_JSON";
    private static final String DELETE_FORM = "DELETE_FORM";
    private static final String DELETE_JSON = "DELETE_JSON";
    /**
     * 账户相关的报错信息
     */
    private static final List<String> ACCOUNT_ERROR_CODE = new ArrayList<>();

    static {
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_ACCOUNT_DISABLE);
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_ACCOUNT_QUIT);
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_ACCOUNT_LOCKED);
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_ACCOUNT_NO_AUTHORITY);
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_ACCOUNT_NO_TEAM);
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_ACCOUNT_MULTIPLE_TEAM);
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_TOKEN_EXPIRED);
        ACCOUNT_ERROR_CODE.add(Constants.Net.Status.CODE_ACCOUNT_POSITION_ERROR);
    }

    /**
     * 构建Get请求
     */
    @NotNull
    public static Request createGet() {
        return create(GET);
    }

    /**
     * 构建PostFrom请求
     */
    @NotNull
    public static Request createPostForm() {
        return create(POST_FORM);
    }

    /**
     * 构建PostJson请求
     */
    @NotNull
    public static Request createPostJson() {
        return create(POST_JSON);
    }

    /**
     * 构建PutForm请求
     */
    @NotNull
    public static Request createPutForm() {
        return create(PUT_FORM);
    }

    /**
     * 构建PutJson请求
     */
    @NotNull
    public static Request createPutJson() {
        return create(PUT_JSON);
    }

    /**
     * 构建DeleteForm请求
     */
    @NotNull
    public static Request createDeleteForm() {
        return create(DELETE_FORM);
    }

    /**
     * 构建DeleteJson请求
     */
    @NotNull
    public static Request createDeleteJson() {
        return create(DELETE_JSON);
    }


    /**
     * 构建请求类型
     */
    @Contract(value = "_ -> new", pure = true)
    @NotNull
    private static Request create(String method) {
        return new Request(method);
    }

    /**
     * 网络请求主类
     */
    public static class Request {
        private String method;
        private String requestId;


        Request(String method) {
            this.method = method;
            requestId = UUID.randomUUID().toString().replaceAll("-", "");
        }

        /**
         * 无参请求返回String类型
         *
         * @param url  请求URL
         */
        public <T> void request(String url, CallBack<String> callBack) {

            if (!NetworkUtil.isNetworkEnabled(BaseApplication.i())) {
                callBack.onError(new ApiException(
                        new Throwable(BaseApplication.i().getString(ResourceTable.String_network_error_no_net)),
                        0x102
                ));
                return;
            }

            if (TextUtils.equals(GET, method)) {
                EasyHttp.get(url)
                        .execute(callBack);
            } else {
                EasyHttp.post(url)
                        .execute(callBack);
            }
        }

        /**
         * 有参请求返回String类型
         *
         * @param url   请求URL
         * @param param 请求参数
         */
        public <T> void request(String url, HttpParams param, CallBack<T> callBack) {

            if (!NetworkUtil.isNetworkEnabled(BaseApplication.i())) {
                callBack.onError(new ApiException(
                        new Throwable(BaseApplication.i().getString(ResourceTable.String_network_error_no_net)),
                        0x102
                ));
                return;
            }

            if (TextUtils.equals(GET, method)) {
                EasyHttp.get(url)
                        .params(param)
                        .execute(callBack);
            } else {
                EasyHttp.post(url)
                        .params(param)
                        .execute(callBack);
            }
        }

        /**
         * 有参请求返回T类型
         *
         * @param life  声明周期实现类
         * @param url   请求URLu
         * @param param 请求参数
         * @param type  响应泛型类型
         */
        public <T> void request(ILifecycle life, String url, RequestParam param, Class<T> type) {

        }

        /**
         * 无参请求返回List<T>类型
         *
         * @param life 声明周期实现类
         * @param url  请求URL
         * @param type 响应泛型类型
         */
        public <T> void requestList(ILifecycle life, String url, Class<T> type) {

        }

        public <T> void requestList(String url, SimpleCallBack<List<T>> callBack) {
            if (!NetworkUtil.isNetworkEnabled(BaseApplication.i())) {
                callBack.onError(new ApiException(
                        new Throwable(BaseApplication.i().getString(ResourceTable.String_network_error_no_net)),
                        0x102
                ));
                return;
            }
            if (TextUtils.equals(GET, method)) {
                EasyHttp.get(url)
                        .execute(callBack);
            } else {
                EasyHttp.post(url)
                        .execute(callBack);
            }

        }

        /**
         * 有参请求返回List<String>类型
         *
         * @param life  声明周期实现类
         * @param url   请求URL
         * @param param 请求参数
         */
        public <T> void requestList(ILifecycle life, String url, RequestParam param) {

        }

        /**
         * 有参请求返回List<T>类型
         *
         * @param life  声明周期实现类
         * @param url   请求URL
         * @param param 请求参数
         * @param type  响应泛型类型
         */
        public <T> void requestList(ILifecycle life, String url, RequestParam param, Class<T> type) {


        }

        /**
         * 检查响应
         *
         * @param apiUrl   接口地址
         * @param response 响应数据
         * @return BaseResponse
         */
        private void checkResponse(String apiUrl, String response) {

        }


        /**
         * 网络请求之前参数检查,组装公共请求参数，加密等操作
         *
         * @param url   接口地址
         * @param param 请求参数
         * @return Observable<String>
         */
        private Observable<String> checkRequest(String url, RequestParam param) {
//            if (!ValidUtils.isValid(param)) {
//                param = new RequestParam();
//            }
//            //打印请求
//            Logger.e(String.format("Request-Id:%s\n%s %s%s\n请求参数：%s", requestId, method, Api.BASE_URL, url, JsonUtils.toJson(param.getParameter())));
//            RxHttp rxHttp = buildRequest(url, param);
//            //添加Header
//            for (Map.Entry<String, String> entry : buildHeader().entrySet()) {
//                rxHttp.addHeader(entry.getKey(), entry.getValue());
//            }
//            return rxHttp.asString();
            return null;
        }

        /**
         * 构建请求
         *
         * @param url   接口地址
         * @param param 请求参数
         * @return RxHttp
         */
        private Object buildRequest(String url, @NotNull RequestParam param) {
//            Map<String, Object> fileMap = new HashMap<>(16);
//            Map<String, Object> paramMap = new HashMap<>(16);
//
//            //分离请求参数中的文件
//            for (Map.Entry<String, Object> entry : param.getParameter().entrySet()) {
//                if (entry.getValue() instanceof File) {
//                    fileMap.put(entry.getKey(), entry.getValue());
//                } else if (entry.getValue() instanceof String) {
//                    //把null转成""
//                    String value = String.valueOf(entry.getValue());
//                    if (!ValidUtils.isValid(value) || "null".equalsIgnoreCase(value)) {
//                        value = "";
//                    }
//                    paramMap.put(entry.getKey(), value);
//                } else {
//                    paramMap.put(entry.getKey(), entry.getValue());
//                }
//            }
//            RxHttp rxHttp;
//            switch (method) {
//                case POST_JSON:
//                case PUT_JSON:
//                case DELETE_JSON:
//                    //JSON格式请求
//                    if (TextUtils.equals(method, POST_JSON)) {
//                        rxHttp = RxHttp.postJson(url);
//                    } else if (TextUtils.equals(method, DELETE_JSON)) {
//                        rxHttp = RxHttp.deleteJson(url);
//                    } else {
//                        rxHttp = RxHttp.putJson(url);
//                    }
//                    ((RxHttpJsonParam) rxHttp).addAll(paramMap);
//                    //添加文件请求参数
//                    if (!fileMap.isEmpty()) {
//                        for (Map.Entry<String, Object> entry : fileMap.entrySet()) {
//                            ((RxHttpJsonParam) rxHttp).add(entry.getKey(), entry.getValue());
//                        }
//                    }
//                    break;
//                case POST_FORM:
//                case PUT_FORM:
//                case DELETE_FORM:
//                    //POST格式请求
//                    if (TextUtils.equals(method, POST_FORM)) {
//                        rxHttp = RxHttp.postForm(url);
//                    } else if (TextUtils.equals(method, DELETE_FORM)) {
//                        rxHttp = RxHttp.deleteForm(url);
//                    } else {
//                        rxHttp = RxHttp.putForm(url);
//                    }
//                    ((RxHttpFormParam) rxHttp).addAll(paramMap);
//                    //添加文件请求参数
//                    if (!fileMap.isEmpty()) {
//                        for (Map.Entry<String, Object> entry : fileMap.entrySet()) {
//                            ((RxHttpFormParam) rxHttp).addFile(entry.getKey(), (File) entry.getValue());
//                        }
//                    }
//                    break;
//                case GET:
//                default:
//                    rxHttp = RxHttp.get(url);
//                    ((RxHttpNoBodyParam) rxHttp).addAll(paramMap);
//                    //添加文件请求参数
//                    if (!fileMap.isEmpty()) {
//                        for (Map.Entry<String, Object> entry : fileMap.entrySet()) {
//                            ((RxHttpNoBodyParam) rxHttp).add(entry.getKey(), entry.getValue());
//                        }
//                    }
//                    break;
//            }
//            return rxHttp;
            return null;
        }

        /**
         * 构建请求头
         *
         * @return 请求头Map
         */
        @NotNull
        private Map<String, String> buildHeader() {
            String deviceId = BaseApplication.i().getDeviceId();
            String token = BaseApplication.i().getLoginToken();
            Map<String, String> header = new HashMap<>();
            header.put(Constants.Net.HEADER_CHANNEL, Constants.Common.CHANEL);
            header.put(Constants.Net.HEADER_API_VERSION, Constants.Common.API_VERSION);
            header.put(Constants.Net.HEADER_DEVICE_ID, ValidUtils.isValid(deviceId) ? deviceId : "");
            header.put(Constants.Net.HEADER_TOKEN, ValidUtils.isValid(token) ? token : "");
            header.put(Constants.Net.HEADER_APP_VERSION, Utils.getVersionName());
            header.put(Constants.Net.HEADER_IP, NetworkUtil.getIpAddress());
            header.put(Constants.Net.REQUEST_ID, requestId);
            Logger.i("请求Header:\n" + JsonUtils.toJson(header));
            return header;
        }


        /**
         * 处理网络请求中的异常
         *
         * @param t Throwable
         * @return NetErrorException
         */
        @Contract("_ -> new")
        @NotNull
        private NetErrorException handleError(@NotNull Throwable t) {
//            BaseApplication.i().removeNetDisposable(requestId);
//            String errorMessage = null;
//            String loggerMessage = "";
//            if (t instanceof SocketTimeoutException) {
//                errorMessage = BaseApplication.i().getString(R.string.request_time_out);
//                loggerMessage = errorMessage;
//            } else if (t instanceof HttpStatusCodeException) {
//                HttpStatusCodeException codeException = (HttpStatusCodeException) t;
//                try {
//                    errorMessage = JsonUtils.getString(codeException.getResult(), Constants.Net.MESSAGE);
//                } catch (Exception e) {
//                    errorMessage = BaseApplication.i().getString(R.string.network_error_server_error);
//                }
//                loggerMessage = String.format("%s %s", codeException.getStatusCode(), errorMessage);
//            } else {
//                loggerMessage = t.getMessage();
//            }
//            if (!ValidUtils.isValid(errorMessage)) {
//                errorMessage = BaseApplication.i().getString(R.string.network_error_server_error);
//            }
//            Logger.e(String.format("Request-Id:%s\n请求报错:%s", requestId, loggerMessage));
            return new NetErrorException("");
        }

        /**
         * 跳转登录页
         *
         * @param errorMessage 错误信息
         */
        private void toLoginActivity(String errorMessage) {

        }
        //--------------------------其他第三方服务请求--------------------------------------------

    }
}
